/// <reference path="../Declarations/forguncy.d.ts" />
/// <reference path="../Declarations/forguncy.Plugin.d.ts" />

/**
 * 生成UUID用于命令唯一标识
 * 优先使用浏览器原生crypto.randomUUID，兼容环境下使用自定义实现
 * @returns {string} 标准UUID字符串
 */
const generateUUID = () => {
    // 优先使用浏览器原生API，更安全高效
    if (typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function') {
        return crypto.randomUUID();
    }

    // 兼容不支持randomUUID的环境
    if (typeof crypto === 'undefined') {
        console.warn('当前环境不支持crypto，UUID生成可能存在安全风险');
        // 降级为基于时间和随机数的简单实现
        const timestamp = new Date().getTime().toString(16);
        const random = Math.random().toString(16).substr(2, 10);
        return `${timestamp}-${random.substr(0, 4)}-4${random.substr(4, 3)}-${(parseInt(random.substr(7, 1), 16) & 3 | 8).toString(16)}${random.substr(8, 3)}-${Math.random().toString(16).substr(2, 12)}`;
    }

    // 基于crypto.getRandomValues的实现（原逻辑优化）
    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
        const r = crypto.getRandomValues(new Uint8Array(1))[0] % 16;
        const v = c === 'x' ? r : (r & 0x3 | 0x8);
        return v.toString(16);
    });
};

/**
 * 插件命令组执行器
 * 支持同步/异步执行一组命令，用于批量处理命令逻辑
 */
class PluginRegionCommand extends Forguncy.Plugin.CommandBase {
    /**
     * 执行命令逻辑
     * @returns {Promise<void>} 异步执行结果
     */
    async execute() {
        var self = this;
        self.runTimePageName = generateUUID();
        try {
            // 从CommandParam获取C#端传递的参数（与PluginRegionCommand.cs属性对应）
            var { RegionName: regionName, SyncFlag: syncFlag, CommandList: commandList } = self.CommandParam;
            var array = Forguncy.ForguncyData.parameterManager.paramStack;
            var arrayInitParams = array.reduce((accumulator, currentValue) => {
                return { ...accumulator, ...currentValue };
            }, {});

            // 校验命令列表有效性
            if (!commandList || !Array.isArray(commandList) || commandList.length === 0) {
                self.log('命令组为空，无需执行');
                return;
            }

            // 生成命令组名称（用于日志和标识）
            var pluginRegionName = `${syncFlag}命令组 ${regionName}`;
            var uuid = generateUUID();

            this.log({ CommandExecutor: self.CommandExecutor })

            // 构建命令执行选项（复用相同配置，减少重复代码）
            var commandOptions = {
                runTimePageName: self.runTimePageName, // 运行时页面标识
                commandID: `regionCommand ${uuid}`,   // 命令唯一ID
                eventType: `regionCommand ${uuid}`,           // 命令类型（用于去重控制）
                locationString: `${pluginRegionName} ${uuid}`, // 日志定位字符串
                callbackOnCommandCompleted: () => {
                    return arrayInitParams
                },
                initParams: arrayInitParams
            };

            // 根据同步/异步标志执行命令
            if (syncFlag === '同步') {
                self.log(`开始同步执行 ${pluginRegionName}`);
                const returnParams = {
                    "returnValues": { "AA": "=AA" }
                };
                self.CommandExecutor.insertCommandsToCurrentExecutingList(
                    commandList,
                    commandOptions.runTimePageName,
                    arrayInitParams,
                    returnParams);
                self.log(`同步执行${pluginRegionName}完成`);
            } else if (syncFlag === '异步') {
                self.log(`开始异步执行 ${pluginRegionName}`);
                self.CommandExecutor.excuteCommand(commandList, commandOptions);
                self.log(`异步执行 ${pluginRegionName} 已触发`);
            } else {
                self.log(`未知执行模式：${syncFlag}，命令未执行`);
            }
        } catch (error) {
            self.log(`命令组执行失败：${error.message || error}`);
            throw error; // 抛出错误便于上层捕获处理
        }
    }
}
Forguncy.Plugin.CommandFactory.registerCommand("PluginRegion.PluginRegionCommand, PluginRegion", PluginRegionCommand);